home *** CD-ROM | disk | FTP | other *** search
/ Acorn User: China / Acorn User China CD-ROM (UK) (Disc A) / Acorn User China CD-ROM (UK) (Disc A).bin / DEMON / MISC / NETLITE2.ARC / NET / c / SESSION < prev    next >
Encoding:
Text File  |  1993-04-10  |  6.7 KB  |  229 lines
  1. /* Session control */
  2. #include <stdio.h>   
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <time.h>
  6. #include "dbox.h"
  7. #include "global.h"
  8. #include "config.h"
  9. #include "mbuf.h"
  10. #include "netuser.h"
  11. #include "timer.h"
  12. #include "tcp.h"
  13. #include "ftp.h"
  14. #include "telnet.h"
  15. #include "finger.h"
  16. #include "ping.h"
  17. #include "session.h"
  18. #include "cmdparse.h"
  19. #include "misc.h"
  20.  
  21. #define Wininfo1_Host     16
  22. #define Wininfo1_Addr     18
  23. #define Wininfo1_Type     20
  24. #define Wininfo1_Status   1
  25. #define Wininfo1_SRTT     3
  26. #define Wininfo1_TWindow  5
  27. #define Wininfo1_RWindow  6
  28. #define Wininfo1_TTotal   11
  29. #define Wininfo1_RTotal   12
  30.  
  31. #define Wininfo2_Host     1
  32.  
  33. #define Wininfo3_Host     1
  34.  
  35. #define Wininfo4_Host     1
  36. #define Wininfo4_Addr     3
  37. #define Wininfo4_Type     5
  38. #define Wininfo4_Interval 7
  39. #define Wininfo4_Size     9
  40.  
  41. struct session *sessions;
  42. char notval[] = "Not a valid control block\n";
  43. char badsess[] = "Invalid session\n";
  44.  
  45. void session_close(struct session *s)
  46. {
  47.         switch(s->type){
  48.         case TELNET:
  49.                 close_tcp(s->cb.telnet->tcb);
  50.                 break;
  51.         case FTP:
  52.                 close_tcp(s->cb.ftp->control);
  53.                 break;
  54.         case FINGER:
  55.                 close_tcp(s->cb.finger->tcb);
  56.                 break;
  57.         case DEAD:
  58.                 Window_Close(s->window);
  59.                 freesession(s);
  60.                 break;
  61.         default:
  62.                 break;
  63.         }
  64. }
  65.  
  66. void session_reset(struct session *s)
  67. {
  68.         switch(s->type){
  69.         case TELNET:
  70.                 reset_tcp(s->cb.telnet->tcb);
  71.                 break;
  72.         case FTP:
  73.                 if(s->cb.ftp->data != NULLTCB){
  74.                         reset_tcp(s->cb.ftp->data);
  75.                         s->cb.ftp->data = NULLTCB;
  76.                 }
  77.                 reset_tcp(s->cb.ftp->control);
  78.                 break;
  79.         case FINGER:
  80.                 reset_tcp(s->cb.finger->tcb);
  81.                 break;
  82.         case DEAD:
  83.                 Window_Close(s->window);
  84.                 freesession(s);
  85.                 break;
  86.         default:
  87.                 break;
  88.         }
  89. }
  90.  
  91. void session_kick(struct session *s)
  92. {
  93.         switch(s->type){
  94.         case TELNET:
  95.                 kick_tcp(s->cb.telnet->tcb);
  96.                 break;
  97.         case FTP:
  98.                 kick_tcp(s->cb.ftp->control);
  99.                 if(s->cb.ftp->data != NULLTCB)
  100.                         kick_tcp(s->cb.ftp->data);
  101.                 break;
  102.         case FINGER:
  103.                 kick_tcp(s->cb.finger->tcb);
  104.                 break;
  105.         case DEAD:
  106.                 Window_Close(s->window);
  107.                 freesession(s);
  108.                 break;
  109.         default:
  110.                 break;
  111.         }
  112. }
  113.  
  114. void session_info(struct session *s)
  115. {
  116.         extern char *tcpstates[];
  117.         struct tcb *tcb;
  118.         struct ping *pp;
  119.         dbox d;
  120.  
  121.         switch (s->type)
  122.         {
  123.                 case RESOLVING:
  124.                      if ((d = dbox_new("wininfo2")) == NULL) return;
  125.                      dbox_setfield(d, Wininfo2_Host, s->name);
  126.                      break;
  127.                 case FTP:
  128.                      if ((d = dbox_new("wininfo1")) == NULL) return;
  129.                      dbox_setfield(d, Wininfo1_Host, s->name);
  130.                      dbox_setfield(d, Wininfo1_Addr, inet_ntoa(s->addr));
  131.                      dbox_setfield(d, Wininfo1_Type, "FTP");
  132.                      tcb = s->cb.ftp->control;
  133.                      break;
  134.                 case TELNET:
  135.                      if ((d = dbox_new("wininfo1")) == NULL) return;
  136.                      dbox_setfield(d, Wininfo1_Host, s->name);
  137.                      dbox_setfield(d, Wininfo1_Addr, inet_ntoa(s->addr));
  138.                      dbox_setfield(d, Wininfo1_Type, "TELNET");
  139.                      tcb = s->cb.telnet->tcb;
  140.                      break;
  141.                 case FINGER:
  142.                      if ((d = dbox_new("wininfo1")) == NULL) return;
  143.                      dbox_setfield(d, Wininfo1_Host, s->name);
  144.                      dbox_setfield(d, Wininfo1_Addr, inet_ntoa(s->addr));
  145.                      dbox_setfield(d, Wininfo1_Type, "FINGER");
  146.                      tcb = s->cb.finger->tcb;
  147.                      break;
  148.                 case PING:
  149.                      if ((d = dbox_new("wininfo4")) == NULL) return;
  150.                      dbox_setfield(d, Wininfo4_Host, s->name);
  151.                      dbox_setfield(d, Wininfo4_Addr, inet_ntoa(s->addr));
  152.                      dbox_setfield(d, Wininfo4_Type, "PING");
  153.                      pp = s->cb.ping;
  154.                      dbox_setnumeric(d, Wininfo4_Interval, pp->interval);
  155.                      dbox_setnumeric(d, Wininfo4_Size,     pp->size);
  156.                      break;
  157.                 case DEAD:
  158.                      if ((d = dbox_new("wininfo3")) == NULL) return;
  159.                      dbox_setfield(d, Wininfo3_Host, s->name);
  160.                      break;
  161.                 default:
  162.                      break;
  163.         }
  164.  
  165.         switch (s->type)
  166.         {
  167.                 case FTP:
  168.                 case TELNET:
  169.                 case FINGER:
  170.                      dbox_setfield(d, Wininfo1_Status, tcpstates[tcb->state]);
  171.                      dbox_setnumeric(d, Wininfo1_SRTT, tcb->srtt);
  172.                      dbox_setnumeric(d, Wininfo1_TWindow, tcb->snd.wnd);
  173.                      dbox_setnumeric(d, Wininfo1_RWindow, tcb->rcv.wnd);
  174.                      dbox_setnumeric(d, Wininfo1_TTotal, tcb->snd.una - tcb->iss - 1);
  175.                      dbox_setnumeric(d, Wininfo1_RTotal, tcb->rcv.nxt - tcb->irs - 1);
  176.                      dbox_show(d);
  177.                      dbox_fillin(d);
  178.                      dbox_dispose(&d);
  179.                      break;
  180.                 case RESOLVING:
  181.                 case PING:
  182.                 case DEAD:
  183.                      dbox_show(d);
  184.                      dbox_fillin(d);
  185.                      dbox_dispose(&d);
  186.                 default:
  187.                      break;
  188.         }
  189. }
  190.  
  191. struct session *newsession(char *title)
  192. {
  193.         register int i;
  194.  
  195.         for (i = 0; i < nsessions; i++) {
  196.                 if (sessions[i].type == FREE) {
  197.                         if ((sessions[i].window = Window_Open((void *)(sessions + i), title)) == NULL)
  198.                                  return NULLSESSION;
  199.                         sessions[i].bufptr = sessions[i].buffer;
  200.                         return &sessions[i];
  201.                 }
  202.         }
  203.  
  204.         return NULLSESSION;
  205. }
  206.  
  207. void detachsession(struct session *s)
  208. {
  209.         if (s == NULLSESSION)
  210.                 return;
  211.  
  212.         Window_Write(s->window, "\nPlease close this window.\n", 27);
  213.  
  214.         s->parse = NULLVFP;
  215.         s->type  = DEAD;
  216. }
  217.  
  218. void freesession(struct session *s)
  219. {
  220.         if (s == NULLSESSION)
  221.                 return;
  222.         if (s->name != NULLCHAR) {
  223.                 free(s->name);
  224.                 s->name = NULLCHAR;
  225.         }
  226.         s->type = FREE;
  227. }
  228.  
  229.